From 966ab1152dc9f803024d7f9b9d95f595a8c2b211 Mon Sep 17 00:00:00 2001 From: Emmanuel Gil Peyrot Date: Fri, 10 Jul 2020 15:53:05 +0200 Subject: [PATCH] gtk/wayland: Add support for idle inhibition in GtkApplication MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit This feature was previously only supported on DBus compositors, such as Mutter, this adds support for other compositors such as all of those based on wlroots. This implementation prefers the idle-inhibit Wayland protocol to the DBus version if it is available, since the inhibitor is per-surface instead of global it allows a finer control over which displays get dimmed for instance. For every case not supported by this protocol, a fallback to the DBus version is used. It can’t do anything if the GtkWindow isn’t passed, which might warrant some documentation change to encourage users to not use NULL for this argument. This has been tested on Sway. Fixes #2202. --- gtk/gtkapplication-wayland.c | 104 ++++++++++++++++++++++++++++++++++- 1 file changed, 103 insertions(+), 1 deletion(-) diff --git a/gtk/gtkapplication-wayland.c b/gtk/gtkapplication-wayland.c index 34d85e31bb..face15505c 100644 --- a/gtk/gtkapplication-wayland.c +++ b/gtk/gtkapplication-wayland.c @@ -1,6 +1,7 @@ /* * Copyright © 2010 Codethink Limited * Copyright © 2013 Canonical Limited + * Copyright © 2020 Emmanuel Gil Peyrot * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public @@ -24,12 +25,42 @@ #include "gtknative.h" #include +#include +#include -typedef GtkApplicationImplDBusClass GtkApplicationImplWaylandClass; +typedef struct +{ + GtkApplicationImplDBusClass parent_class; + + /* stores the dbus version of the overriden methods */ + guint (*dbus_inhibit) (GtkApplicationImpl *impl, + GtkWindow *window, + GtkApplicationInhibitFlags flags, + const gchar *reason); + void (*dbus_uninhibit) (GtkApplicationImpl *impl, + guint cookie); +} GtkApplicationImplWaylandClass; + +typedef struct +{ + guint cookie; + guint dbus_cookie; + GtkApplicationInhibitFlags flags; + GdkSurface *surface; + +} GtkApplicationWaylandInhibitor; + +static void +gtk_application_wayland_inhibitor_free (GtkApplicationWaylandInhibitor *inhibitor) +{ + g_slice_free (GtkApplicationWaylandInhibitor, inhibitor); +} typedef struct { GtkApplicationImplDBus dbus; + GSList *inhibitors; + guint next_cookie; } GtkApplicationImplWayland; @@ -72,6 +103,70 @@ gtk_application_impl_wayland_before_emit (GtkApplicationImpl *impl, gdk_wayland_display_set_startup_notification_id (gdk_display_get_default (), startup_notification_id); } +static guint +gtk_application_impl_wayland_inhibit (GtkApplicationImpl *impl, + GtkWindow *window, + GtkApplicationInhibitFlags flags, + const gchar *reason) +{ + GtkApplicationImplWayland *wayland = (GtkApplicationImplWayland *) impl; + GdkSurface *surface; + GtkApplicationWaylandInhibitor *inhibitor; + gboolean success; + + if (!flags) + return 0; + + inhibitor = g_slice_new (GtkApplicationWaylandInhibitor); + inhibitor->cookie = ++wayland->next_cookie; + inhibitor->flags = flags; + wayland->inhibitors = g_slist_prepend (wayland->inhibitors, inhibitor); + + if (flags & GTK_APPLICATION_INHIBIT_IDLE) + { + surface = gtk_native_get_surface (GTK_NATIVE (window)); + if (GDK_IS_WAYLAND_SURFACE (surface)) + { + success = gdk_wayland_surface_inhibit_idle (surface); + if (success) + { + flags &= ~GTK_APPLICATION_INHIBIT_IDLE; + inhibitor->surface = surface; + } + } + } + + inhibitor->dbus_cookie = ((GtkApplicationImplWaylandClass *) G_OBJECT_GET_CLASS (wayland))->dbus_inhibit (impl, window, flags, reason); + + return inhibitor->cookie; +} + +static void +gtk_application_impl_wayland_uninhibit (GtkApplicationImpl *impl, + guint cookie) +{ + GtkApplicationImplWayland *wayland = (GtkApplicationImplWayland *) impl; + GSList *iter; + + for (iter = wayland->inhibitors; iter; iter = iter->next) + { + GtkApplicationWaylandInhibitor *inhibitor = iter->data; + + if (inhibitor->cookie == cookie) + { + if (inhibitor->dbus_cookie) + ((GtkApplicationImplWaylandClass *) G_OBJECT_GET_CLASS (wayland))->dbus_uninhibit (impl, inhibitor->dbus_cookie); + if (inhibitor->surface) + gdk_wayland_surface_uninhibit_idle (inhibitor->surface); + gtk_application_wayland_inhibitor_free (inhibitor); + wayland->inhibitors = g_slist_delete_link (wayland->inhibitors, iter); + return; + } + } + + g_warning ("Invalid inhibitor cookie"); +} + static void gtk_application_impl_wayland_init (GtkApplicationImplWayland *wayland) { @@ -82,8 +177,15 @@ gtk_application_impl_wayland_class_init (GtkApplicationImplWaylandClass *class) { GtkApplicationImplClass *impl_class = GTK_APPLICATION_IMPL_CLASS (class); + class->dbus_inhibit = impl_class->inhibit; + class->dbus_uninhibit = impl_class->uninhibit; + impl_class->handle_window_realize = gtk_application_impl_wayland_handle_window_realize; impl_class->before_emit = gtk_application_impl_wayland_before_emit; + impl_class->inhibit = + gtk_application_impl_wayland_inhibit; + impl_class->uninhibit = + gtk_application_impl_wayland_uninhibit; } -- 2.30.2